// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.wfs.cargo.item;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.WfsCargoItem;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(WfsCargoItem.class)
@Setter
@Getter
public class WfsCargoItemSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "WfsCargoItem".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("parentWfsCargo", "wc");
    map.put("productName", "p");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 所属WFS货件
   */
  private Long parentWfsCargo;

  /**
   * 所属WFS货件 比较(eq)
   */
  private Long parentWfsCargoEq;
  /**
   * 所属WFS货件 比较(neq)
   */
  private Long parentWfsCargoNeq;
  /**
   * 所属WFS货件 比较(gt)
   */
  private Long parentWfsCargoGt;
  /**
   * 所属WFS货件 比较(gte)
   */
  private Long parentWfsCargoGte;
  /**
   * 所属WFS货件 比较(lt)
   */
  private Long parentWfsCargoLt;
  /**
   * 所属WFS货件 比较(lte)
   */
  private Long parentWfsCargoLte;
  /**
   * 所属WFS货件 比较(contains)
   */
  private Long parentWfsCargoContains;
  /**
   * 所属WFS货件 比较(notcontains)
   */
  private Long parentWfsCargoNotcontains;
  /**
   * 所属WFS货件 比较(startswith)
   */
  private Long parentWfsCargoStartswith;
  /**
   * 所属WFS货件 比较(endswith)
   */
  private Long parentWfsCargoEndswith;
  /**
   * 所属WFS货件 比较(isnull)
   */
  private Boolean parentWfsCargoIsnull;
  /**
   * 所属WFS货件 比较(isnotnull)
   */
  private Boolean parentWfsCargoIsnotnull;
  /**
   * 所属WFS货件的货件单号 比较(eq)
   */
  private String parentWfsCargoCargoCodeEq;
  /**
   * 所属WFS货件的货件单号 比较(neq)
   */
  private String parentWfsCargoCargoCodeNeq;
  /**
   * 所属WFS货件的货件单号 比较(gt)
   */
  private String parentWfsCargoCargoCodeGt;
  /**
   * 所属WFS货件的货件单号 比较(gte)
   */
  private String parentWfsCargoCargoCodeGte;
  /**
   * 所属WFS货件的货件单号 比较(lt)
   */
  private String parentWfsCargoCargoCodeLt;
  /**
   * 所属WFS货件的货件单号 比较(lte)
   */
  private String parentWfsCargoCargoCodeLte;
  /**
   * 所属WFS货件的货件单号 比较(contains)
   */
  private String parentWfsCargoCargoCodeContains;
  /**
   * 所属WFS货件的货件单号 比较(notcontains)
   */
  private String parentWfsCargoCargoCodeNotcontains;
  /**
   * 所属WFS货件的货件单号 比较(startswith)
   */
  private String parentWfsCargoCargoCodeStartswith;
  /**
   * 所属WFS货件的货件单号 比较(endswith)
   */
  private String parentWfsCargoCargoCodeEndswith;
  /**
   * 所属WFS货件的货件单号 比较(isnull)
   */
  private Boolean parentWfsCargoCargoCodeIsnull;
  /**
   * 所属WFS货件的货件单号 比较(isnotnull)
   */
  private Boolean parentWfsCargoCargoCodeIsnotnull;

  /**
   * 所属WFS货件(范围搜索)
   */
  private List<Long> parentWfsCargoInList;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 图片(模糊搜索)
   */
  private String img;

  /**
   * 图片 比较(eq)
   */
  private String imgEq;
  /**
   * 图片 比较(neq)
   */
  private String imgNeq;
  /**
   * 图片 比较(gt)
   */
  private String imgGt;
  /**
   * 图片 比较(gte)
   */
  private String imgGte;
  /**
   * 图片 比较(lt)
   */
  private String imgLt;
  /**
   * 图片 比较(lte)
   */
  private String imgLte;
  /**
   * 图片 比较(contains)
   */
  private String imgContains;
  /**
   * 图片 比较(notcontains)
   */
  private String imgNotcontains;
  /**
   * 图片 比较(startswith)
   */
  private String imgStartswith;
  /**
   * 图片 比较(endswith)
   */
  private String imgEndswith;
  /**
   * 图片 比较(isnull)
   */
  private Boolean imgIsnull;
  /**
   * 图片 比较(isnotnull)
   */
  private Boolean imgIsnotnull;

  /**
   * 图片(精确搜索)
   */
  private List<String> imgInList;

  /**
   * MSKU(模糊搜索)
   */
  private String msku;

  /**
   * MSKU 比较(eq)
   */
  private String mskuEq;
  /**
   * MSKU 比较(neq)
   */
  private String mskuNeq;
  /**
   * MSKU 比较(gt)
   */
  private String mskuGt;
  /**
   * MSKU 比较(gte)
   */
  private String mskuGte;
  /**
   * MSKU 比较(lt)
   */
  private String mskuLt;
  /**
   * MSKU 比较(lte)
   */
  private String mskuLte;
  /**
   * MSKU 比较(contains)
   */
  private String mskuContains;
  /**
   * MSKU 比较(notcontains)
   */
  private String mskuNotcontains;
  /**
   * MSKU 比较(startswith)
   */
  private String mskuStartswith;
  /**
   * MSKU 比较(endswith)
   */
  private String mskuEndswith;
  /**
   * MSKU 比较(isnull)
   */
  private Boolean mskuIsnull;
  /**
   * MSKU 比较(isnotnull)
   */
  private Boolean mskuIsnotnull;

  /**
   * MSKU(精确搜索)
   */
  private List<String> mskuInList;

  /**
   * GTIN码(模糊搜索)
   */
  private String gtin;

  /**
   * GTIN码 比较(eq)
   */
  private String gtinEq;
  /**
   * GTIN码 比较(neq)
   */
  private String gtinNeq;
  /**
   * GTIN码 比较(gt)
   */
  private String gtinGt;
  /**
   * GTIN码 比较(gte)
   */
  private String gtinGte;
  /**
   * GTIN码 比较(lt)
   */
  private String gtinLt;
  /**
   * GTIN码 比较(lte)
   */
  private String gtinLte;
  /**
   * GTIN码 比较(contains)
   */
  private String gtinContains;
  /**
   * GTIN码 比较(notcontains)
   */
  private String gtinNotcontains;
  /**
   * GTIN码 比较(startswith)
   */
  private String gtinStartswith;
  /**
   * GTIN码 比较(endswith)
   */
  private String gtinEndswith;
  /**
   * GTIN码 比较(isnull)
   */
  private Boolean gtinIsnull;
  /**
   * GTIN码 比较(isnotnull)
   */
  private Boolean gtinIsnotnull;

  /**
   * GTIN码(精确搜索)
   */
  private List<String> gtinInList;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 品名
   */
  private Long productName;

  /**
   * 品名 比较(eq)
   */
  private Long productNameEq;
  /**
   * 品名 比较(neq)
   */
  private Long productNameNeq;
  /**
   * 品名 比较(gt)
   */
  private Long productNameGt;
  /**
   * 品名 比较(gte)
   */
  private Long productNameGte;
  /**
   * 品名 比较(lt)
   */
  private Long productNameLt;
  /**
   * 品名 比较(lte)
   */
  private Long productNameLte;
  /**
   * 品名 比较(contains)
   */
  private Long productNameContains;
  /**
   * 品名 比较(notcontains)
   */
  private Long productNameNotcontains;
  /**
   * 品名 比较(startswith)
   */
  private Long productNameStartswith;
  /**
   * 品名 比较(endswith)
   */
  private Long productNameEndswith;
  /**
   * 品名 比较(isnull)
   */
  private Boolean productNameIsnull;
  /**
   * 品名 比较(isnotnull)
   */
  private Boolean productNameIsnotnull;
  /**
   * 品名的品名 比较(eq)
   */
  private String productNameNameEq;
  /**
   * 品名的品名 比较(neq)
   */
  private String productNameNameNeq;
  /**
   * 品名的品名 比较(gt)
   */
  private String productNameNameGt;
  /**
   * 品名的品名 比较(gte)
   */
  private String productNameNameGte;
  /**
   * 品名的品名 比较(lt)
   */
  private String productNameNameLt;
  /**
   * 品名的品名 比较(lte)
   */
  private String productNameNameLte;
  /**
   * 品名的品名 比较(contains)
   */
  private String productNameNameContains;
  /**
   * 品名的品名 比较(notcontains)
   */
  private String productNameNameNotcontains;
  /**
   * 品名的品名 比较(startswith)
   */
  private String productNameNameStartswith;
  /**
   * 品名的品名 比较(endswith)
   */
  private String productNameNameEndswith;
  /**
   * 品名的品名 比较(isnull)
   */
  private Boolean productNameNameIsnull;
  /**
   * 品名的品名 比较(isnotnull)
   */
  private Boolean productNameNameIsnotnull;

  /**
   * 品名(范围搜索)
   */
  private List<Long> productNameInList;

  /**
   * SKU(模糊搜索)
   */
  private String sku;

  /**
   * SKU 比较(eq)
   */
  private String skuEq;
  /**
   * SKU 比较(neq)
   */
  private String skuNeq;
  /**
   * SKU 比较(gt)
   */
  private String skuGt;
  /**
   * SKU 比较(gte)
   */
  private String skuGte;
  /**
   * SKU 比较(lt)
   */
  private String skuLt;
  /**
   * SKU 比较(lte)
   */
  private String skuLte;
  /**
   * SKU 比较(contains)
   */
  private String skuContains;
  /**
   * SKU 比较(notcontains)
   */
  private String skuNotcontains;
  /**
   * SKU 比较(startswith)
   */
  private String skuStartswith;
  /**
   * SKU 比较(endswith)
   */
  private String skuEndswith;
  /**
   * SKU 比较(isnull)
   */
  private Boolean skuIsnull;
  /**
   * SKU 比较(isnotnull)
   */
  private Boolean skuIsnotnull;

  /**
   * SKU(精确搜索)
   */
  private List<String> skuInList;

  /**
   * 商品类型
   */
  private String productType;

  /**
   * 商品类型 比较(eq)
   */
  private String productTypeEq;
  /**
   * 商品类型 比较(neq)
   */
  private String productTypeNeq;
  /**
   * 商品类型 比较(gt)
   */
  private String productTypeGt;
  /**
   * 商品类型 比较(gte)
   */
  private String productTypeGte;
  /**
   * 商品类型 比较(lt)
   */
  private String productTypeLt;
  /**
   * 商品类型 比较(lte)
   */
  private String productTypeLte;
  /**
   * 商品类型 比较(contains)
   */
  private String productTypeContains;
  /**
   * 商品类型 比较(notcontains)
   */
  private String productTypeNotcontains;
  /**
   * 商品类型 比较(startswith)
   */
  private String productTypeStartswith;
  /**
   * 商品类型 比较(endswith)
   */
  private String productTypeEndswith;
  /**
   * 商品类型 比较(isnull)
   */
  private Boolean productTypeIsnull;
  /**
   * 商品类型 比较(isnotnull)
   */
  private Boolean productTypeIsnotnull;

  /**
   * 商品类型(精确搜索)
   */
  private List<String> productTypeInList;

  /**
   * 商品描述(模糊搜索)
   */
  private String productDescribe;

  /**
   * 商品描述 比较(eq)
   */
  private String productDescribeEq;
  /**
   * 商品描述 比较(neq)
   */
  private String productDescribeNeq;
  /**
   * 商品描述 比较(gt)
   */
  private String productDescribeGt;
  /**
   * 商品描述 比较(gte)
   */
  private String productDescribeGte;
  /**
   * 商品描述 比较(lt)
   */
  private String productDescribeLt;
  /**
   * 商品描述 比较(lte)
   */
  private String productDescribeLte;
  /**
   * 商品描述 比较(contains)
   */
  private String productDescribeContains;
  /**
   * 商品描述 比较(notcontains)
   */
  private String productDescribeNotcontains;
  /**
   * 商品描述 比较(startswith)
   */
  private String productDescribeStartswith;
  /**
   * 商品描述 比较(endswith)
   */
  private String productDescribeEndswith;
  /**
   * 商品描述 比较(isnull)
   */
  private Boolean productDescribeIsnull;
  /**
   * 商品描述 比较(isnotnull)
   */
  private Boolean productDescribeIsnotnull;

  /**
   * 商品描述(精确搜索)
   */
  private List<String> productDescribeInList;

  /**
   * 申报量
   */
  private Integer declareNum;

  /**
   * 最小申报量
   */
  private Integer declareNumMin;

  /**
   * 最大申报量
   */
  private Integer declareNumMax;

  /**
   * 申报量 比较(eq)
   */
  private Integer declareNumEq;
  /**
   * 申报量 比较(neq)
   */
  private Integer declareNumNeq;
  /**
   * 申报量 比较(gt)
   */
  private Integer declareNumGt;
  /**
   * 申报量 比较(gte)
   */
  private Integer declareNumGte;
  /**
   * 申报量 比较(lt)
   */
  private Integer declareNumLt;
  /**
   * 申报量 比较(lte)
   */
  private Integer declareNumLte;
  /**
   * 申报量 比较(contains)
   */
  private Integer declareNumContains;
  /**
   * 申报量 比较(notcontains)
   */
  private Integer declareNumNotcontains;
  /**
   * 申报量 比较(startswith)
   */
  private Integer declareNumStartswith;
  /**
   * 申报量 比较(endswith)
   */
  private Integer declareNumEndswith;
  /**
   * 申报量 比较(isnull)
   */
  private Boolean declareNumIsnull;
  /**
   * 申报量 比较(isnotnull)
   */
  private Boolean declareNumIsnotnull;

  /**
   * 发货状态
   */
  private String shipstatus;

  /**
   * 发货状态 比较(eq)
   */
  private String shipstatusEq;
  /**
   * 发货状态 比较(neq)
   */
  private String shipstatusNeq;
  /**
   * 发货状态 比较(gt)
   */
  private String shipstatusGt;
  /**
   * 发货状态 比较(gte)
   */
  private String shipstatusGte;
  /**
   * 发货状态 比较(lt)
   */
  private String shipstatusLt;
  /**
   * 发货状态 比较(lte)
   */
  private String shipstatusLte;
  /**
   * 发货状态 比较(contains)
   */
  private String shipstatusContains;
  /**
   * 发货状态 比较(notcontains)
   */
  private String shipstatusNotcontains;
  /**
   * 发货状态 比较(startswith)
   */
  private String shipstatusStartswith;
  /**
   * 发货状态 比较(endswith)
   */
  private String shipstatusEndswith;
  /**
   * 发货状态 比较(isnull)
   */
  private Boolean shipstatusIsnull;
  /**
   * 发货状态 比较(isnotnull)
   */
  private Boolean shipstatusIsnotnull;

  /**
   * 发货状态(精确搜索)
   */
  private List<String> shipstatusInList;

  /**
   * 签收量
   */
  private Long receivedquantity;

  /**
   * 最小签收量
   */
  private Long receivedquantityMin;

  /**
   * 最大签收量
   */
  private Long receivedquantityMax;

  /**
   * 签收量 比较(eq)
   */
  private Long receivedquantityEq;
  /**
   * 签收量 比较(neq)
   */
  private Long receivedquantityNeq;
  /**
   * 签收量 比较(gt)
   */
  private Long receivedquantityGt;
  /**
   * 签收量 比较(gte)
   */
  private Long receivedquantityGte;
  /**
   * 签收量 比较(lt)
   */
  private Long receivedquantityLt;
  /**
   * 签收量 比较(lte)
   */
  private Long receivedquantityLte;
  /**
   * 签收量 比较(contains)
   */
  private Long receivedquantityContains;
  /**
   * 签收量 比较(notcontains)
   */
  private Long receivedquantityNotcontains;
  /**
   * 签收量 比较(startswith)
   */
  private Long receivedquantityStartswith;
  /**
   * 签收量 比较(endswith)
   */
  private Long receivedquantityEndswith;
  /**
   * 签收量 比较(isnull)
   */
  private Boolean receivedquantityIsnull;
  /**
   * 签收量 比较(isnotnull)
   */
  private Boolean receivedquantityIsnotnull;

  /**
   * 箱子数量
   */
  private Integer boxNum;

  /**
   * 最小箱子数量
   */
  private Integer boxNumMin;

  /**
   * 最大箱子数量
   */
  private Integer boxNumMax;

  /**
   * 箱子数量 比较(eq)
   */
  private Integer boxNumEq;
  /**
   * 箱子数量 比较(neq)
   */
  private Integer boxNumNeq;
  /**
   * 箱子数量 比较(gt)
   */
  private Integer boxNumGt;
  /**
   * 箱子数量 比较(gte)
   */
  private Integer boxNumGte;
  /**
   * 箱子数量 比较(lt)
   */
  private Integer boxNumLt;
  /**
   * 箱子数量 比较(lte)
   */
  private Integer boxNumLte;
  /**
   * 箱子数量 比较(contains)
   */
  private Integer boxNumContains;
  /**
   * 箱子数量 比较(notcontains)
   */
  private Integer boxNumNotcontains;
  /**
   * 箱子数量 比较(startswith)
   */
  private Integer boxNumStartswith;
  /**
   * 箱子数量 比较(endswith)
   */
  private Integer boxNumEndswith;
  /**
   * 箱子数量 比较(isnull)
   */
  private Boolean boxNumIsnull;
  /**
   * 箱子数量 比较(isnotnull)
   */
  private Boolean boxNumIsnotnull;

  /**
   * 单箱产品数量
   */
  private Integer singleboxquantity;

  /**
   * 最小单箱产品数量
   */
  private Integer singleboxquantityMin;

  /**
   * 最大单箱产品数量
   */
  private Integer singleboxquantityMax;

  /**
   * 单箱产品数量 比较(eq)
   */
  private Integer singleboxquantityEq;
  /**
   * 单箱产品数量 比较(neq)
   */
  private Integer singleboxquantityNeq;
  /**
   * 单箱产品数量 比较(gt)
   */
  private Integer singleboxquantityGt;
  /**
   * 单箱产品数量 比较(gte)
   */
  private Integer singleboxquantityGte;
  /**
   * 单箱产品数量 比较(lt)
   */
  private Integer singleboxquantityLt;
  /**
   * 单箱产品数量 比较(lte)
   */
  private Integer singleboxquantityLte;
  /**
   * 单箱产品数量 比较(contains)
   */
  private Integer singleboxquantityContains;
  /**
   * 单箱产品数量 比较(notcontains)
   */
  private Integer singleboxquantityNotcontains;
  /**
   * 单箱产品数量 比较(startswith)
   */
  private Integer singleboxquantityStartswith;
  /**
   * 单箱产品数量 比较(endswith)
   */
  private Integer singleboxquantityEndswith;
  /**
   * 单箱产品数量 比较(isnull)
   */
  private Boolean singleboxquantityIsnull;
  /**
   * 单箱产品数量 比较(isnotnull)
   */
  private Boolean singleboxquantityIsnotnull;

  /**
   * 最早预估到期时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date estimatedExpirationTimeStart;

  /**
   * 最晚预估到期时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date estimatedExpirationTimeEnd;

  /**
   * 预估到期时间 比较(eq)
   */
  private Date estimatedExpirationTimeEq;
  /**
   * 预估到期时间 比较(neq)
   */
  private Date estimatedExpirationTimeNeq;
  /**
   * 预估到期时间 比较(gt)
   */
  private Date estimatedExpirationTimeGt;
  /**
   * 预估到期时间 比较(gte)
   */
  private Date estimatedExpirationTimeGte;
  /**
   * 预估到期时间 比较(lt)
   */
  private Date estimatedExpirationTimeLt;
  /**
   * 预估到期时间 比较(lte)
   */
  private Date estimatedExpirationTimeLte;
  /**
   * 预估到期时间 比较(contains)
   */
  private Date estimatedExpirationTimeContains;
  /**
   * 预估到期时间 比较(notcontains)
   */
  private Date estimatedExpirationTimeNotcontains;
  /**
   * 预估到期时间 比较(startswith)
   */
  private Date estimatedExpirationTimeStartswith;
  /**
   * 预估到期时间 比较(endswith)
   */
  private Date estimatedExpirationTimeEndswith;
  /**
   * 预估到期时间 比较(isnull)
   */
  private Boolean estimatedExpirationTimeIsnull;
  /**
   * 预估到期时间 比较(isnotnull)
   */
  private Boolean estimatedExpirationTimeIsnotnull;

  /**
   * 增值服务
   */
  private String valueaddedservices;

  /**
   * 增值服务 比较(eq)
   */
  private String valueaddedservicesEq;
  /**
   * 增值服务 比较(neq)
   */
  private String valueaddedservicesNeq;
  /**
   * 增值服务 比较(gt)
   */
  private String valueaddedservicesGt;
  /**
   * 增值服务 比较(gte)
   */
  private String valueaddedservicesGte;
  /**
   * 增值服务 比较(lt)
   */
  private String valueaddedservicesLt;
  /**
   * 增值服务 比较(lte)
   */
  private String valueaddedservicesLte;
  /**
   * 增值服务 比较(contains)
   */
  private String valueaddedservicesContains;
  /**
   * 增值服务 比较(notcontains)
   */
  private String valueaddedservicesNotcontains;
  /**
   * 增值服务 比较(startswith)
   */
  private String valueaddedservicesStartswith;
  /**
   * 增值服务 比较(endswith)
   */
  private String valueaddedservicesEndswith;
  /**
   * 增值服务 比较(isnull)
   */
  private Boolean valueaddedservicesIsnull;
  /**
   * 增值服务 比较(isnotnull)
   */
  private Boolean valueaddedservicesIsnotnull;

  /**
   * 增值服务(精确搜索)
   */
  private List<String> valueaddedservicesInList;

  /**
   * 签收数量(损坏)
   */
  private Integer receivedNum;

  /**
   * 最小签收数量(损坏)
   */
  private Integer receivedNumMin;

  /**
   * 最大签收数量(损坏)
   */
  private Integer receivedNumMax;

  /**
   * 签收数量(损坏) 比较(eq)
   */
  private Integer receivedNumEq;
  /**
   * 签收数量(损坏) 比较(neq)
   */
  private Integer receivedNumNeq;
  /**
   * 签收数量(损坏) 比较(gt)
   */
  private Integer receivedNumGt;
  /**
   * 签收数量(损坏) 比较(gte)
   */
  private Integer receivedNumGte;
  /**
   * 签收数量(损坏) 比较(lt)
   */
  private Integer receivedNumLt;
  /**
   * 签收数量(损坏) 比较(lte)
   */
  private Integer receivedNumLte;
  /**
   * 签收数量(损坏) 比较(contains)
   */
  private Integer receivedNumContains;
  /**
   * 签收数量(损坏) 比较(notcontains)
   */
  private Integer receivedNumNotcontains;
  /**
   * 签收数量(损坏) 比较(startswith)
   */
  private Integer receivedNumStartswith;
  /**
   * 签收数量(损坏) 比较(endswith)
   */
  private Integer receivedNumEndswith;
  /**
   * 签收数量(损坏) 比较(isnull)
   */
  private Boolean receivedNumIsnull;
  /**
   * 签收数量(损坏) 比较(isnotnull)
   */
  private Boolean receivedNumIsnotnull;

  /**
   * 已发货数量
   */
  private Integer shipmentsNum;

  /**
   * 最小已发货数量
   */
  private Integer shipmentsNumMin;

  /**
   * 最大已发货数量
   */
  private Integer shipmentsNumMax;

  /**
   * 已发货数量 比较(eq)
   */
  private Integer shipmentsNumEq;
  /**
   * 已发货数量 比较(neq)
   */
  private Integer shipmentsNumNeq;
  /**
   * 已发货数量 比较(gt)
   */
  private Integer shipmentsNumGt;
  /**
   * 已发货数量 比较(gte)
   */
  private Integer shipmentsNumGte;
  /**
   * 已发货数量 比较(lt)
   */
  private Integer shipmentsNumLt;
  /**
   * 已发货数量 比较(lte)
   */
  private Integer shipmentsNumLte;
  /**
   * 已发货数量 比较(contains)
   */
  private Integer shipmentsNumContains;
  /**
   * 已发货数量 比较(notcontains)
   */
  private Integer shipmentsNumNotcontains;
  /**
   * 已发货数量 比较(startswith)
   */
  private Integer shipmentsNumStartswith;
  /**
   * 已发货数量 比较(endswith)
   */
  private Integer shipmentsNumEndswith;
  /**
   * 已发货数量 比较(isnull)
   */
  private Boolean shipmentsNumIsnull;
  /**
   * 已发货数量 比较(isnotnull)
   */
  private Boolean shipmentsNumIsnotnull;

  /**
   * 申发差异
   */
  private Integer shenfadifference;

  /**
   * 最小申发差异
   */
  private Integer shenfadifferenceMin;

  /**
   * 最大申发差异
   */
  private Integer shenfadifferenceMax;

  /**
   * 申发差异 比较(eq)
   */
  private Integer shenfadifferenceEq;
  /**
   * 申发差异 比较(neq)
   */
  private Integer shenfadifferenceNeq;
  /**
   * 申发差异 比较(gt)
   */
  private Integer shenfadifferenceGt;
  /**
   * 申发差异 比较(gte)
   */
  private Integer shenfadifferenceGte;
  /**
   * 申发差异 比较(lt)
   */
  private Integer shenfadifferenceLt;
  /**
   * 申发差异 比较(lte)
   */
  private Integer shenfadifferenceLte;
  /**
   * 申发差异 比较(contains)
   */
  private Integer shenfadifferenceContains;
  /**
   * 申发差异 比较(notcontains)
   */
  private Integer shenfadifferenceNotcontains;
  /**
   * 申发差异 比较(startswith)
   */
  private Integer shenfadifferenceStartswith;
  /**
   * 申发差异 比较(endswith)
   */
  private Integer shenfadifferenceEndswith;
  /**
   * 申发差异 比较(isnull)
   */
  private Boolean shenfadifferenceIsnull;
  /**
   * 申发差异 比较(isnotnull)
   */
  private Boolean shenfadifferenceIsnotnull;

  /**
   * 申收差异
   */
  private Integer shenshoudifference;

  /**
   * 最小申收差异
   */
  private Integer shenshoudifferenceMin;

  /**
   * 最大申收差异
   */
  private Integer shenshoudifferenceMax;

  /**
   * 申收差异 比较(eq)
   */
  private Integer shenshoudifferenceEq;
  /**
   * 申收差异 比较(neq)
   */
  private Integer shenshoudifferenceNeq;
  /**
   * 申收差异 比较(gt)
   */
  private Integer shenshoudifferenceGt;
  /**
   * 申收差异 比较(gte)
   */
  private Integer shenshoudifferenceGte;
  /**
   * 申收差异 比较(lt)
   */
  private Integer shenshoudifferenceLt;
  /**
   * 申收差异 比较(lte)
   */
  private Integer shenshoudifferenceLte;
  /**
   * 申收差异 比较(contains)
   */
  private Integer shenshoudifferenceContains;
  /**
   * 申收差异 比较(notcontains)
   */
  private Integer shenshoudifferenceNotcontains;
  /**
   * 申收差异 比较(startswith)
   */
  private Integer shenshoudifferenceStartswith;
  /**
   * 申收差异 比较(endswith)
   */
  private Integer shenshoudifferenceEndswith;
  /**
   * 申收差异 比较(isnull)
   */
  private Boolean shenshoudifferenceIsnull;
  /**
   * 申收差异 比较(isnotnull)
   */
  private Boolean shenshoudifferenceIsnotnull;

  /**
   * 收发差异
   */
  private Integer shoufadifference;

  /**
   * 最小收发差异
   */
  private Integer shoufadifferenceMin;

  /**
   * 最大收发差异
   */
  private Integer shoufadifferenceMax;

  /**
   * 收发差异 比较(eq)
   */
  private Integer shoufadifferenceEq;
  /**
   * 收发差异 比较(neq)
   */
  private Integer shoufadifferenceNeq;
  /**
   * 收发差异 比较(gt)
   */
  private Integer shoufadifferenceGt;
  /**
   * 收发差异 比较(gte)
   */
  private Integer shoufadifferenceGte;
  /**
   * 收发差异 比较(lt)
   */
  private Integer shoufadifferenceLt;
  /**
   * 收发差异 比较(lte)
   */
  private Integer shoufadifferenceLte;
  /**
   * 收发差异 比较(contains)
   */
  private Integer shoufadifferenceContains;
  /**
   * 收发差异 比较(notcontains)
   */
  private Integer shoufadifferenceNotcontains;
  /**
   * 收发差异 比较(startswith)
   */
  private Integer shoufadifferenceStartswith;
  /**
   * 收发差异 比较(endswith)
   */
  private Integer shoufadifferenceEndswith;
  /**
   * 收发差异 比较(isnull)
   */
  private Boolean shoufadifferenceIsnull;
  /**
   * 收发差异 比较(isnotnull)
   */
  private Boolean shoufadifferenceIsnotnull;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
